home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 1.iso / toolbox / src / demos / OpenGL / backtrace / main.c++ < prev    next >
C/C++ Source or Header  |  1996-11-11  |  11KB  |  331 lines
  1. /*
  2.  * (c) Copyright 1993, Silicon Graphics, Inc.
  3.  * ALL RIGHTS RESERVED 
  4.  * Permission to use, copy, modify, and distribute this software for 
  5.  * any purpose and without fee is hereby granted, provided that the above
  6.  * copyright notice appear in all copies and that both the copyright notice
  7.  * and this permission notice appear in supporting documentation, and that 
  8.  * the name of Silicon Graphics, Inc. not be used in advertising
  9.  * or publicity pertaining to distribution of the software without specific,
  10.  * written prior permission. 
  11.  *
  12.  * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"
  13.  * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,
  14.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR
  15.  * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON
  16.  * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,
  17.  * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY
  18.  * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,
  19.  * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF
  20.  * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN
  21.  * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON
  22.  * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE
  23.  * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.
  24.  * 
  25.  * US Government Users Restricted Rights 
  26.  * Use, duplication, or disclosure by the Government is subject to
  27.  * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
  28.  * (c)(1)(ii) of the Rights in Technical Data and Computer Software
  29.  * clause at DFARS 252.227-7013 and/or in similar or successor
  30.  * clauses in the FAR or the DOD or NASA FAR Supplement.
  31.  * Unpublished-- rights reserved under the copyright laws of the
  32.  * United States.  Contractor/manufacturer is Silicon Graphics,
  33.  * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.
  34.  *
  35.  * OpenGL(TM) is a trademark of Silicon Graphics, Inc.
  36.  */
  37. #include <GL/glu.h>
  38. #include <GL/glx.h>
  39.  
  40. #include <X11/Intrinsic.h>
  41. #include <Xm/Xm.h>
  42. #include <Xm/CascadeB.h>
  43. #include <Xm/Frame.h>
  44. #include <Xm/MainW.h>
  45. #include <Xm/PushB.h>
  46. #include <Xm/PushBG.h>
  47. #include <Xm/RowColumn.h>
  48. #include <Xm/ToggleB.h>
  49.  
  50. #include <GL/glu.h>
  51. #include <GL/glx.h>
  52.  
  53. #include <GL/GLwMDrawA.h>
  54.  
  55. #include <math.h>
  56. #include <stdio.h>
  57. #include <stdlib.h>
  58. #include <sys/time.h>
  59.  
  60. #include "scene.h"
  61. #include "callbacks.h"
  62.  
  63. static Display *display;
  64. XtAppContext app_context;
  65. Widget glw;
  66.  
  67. const int max_args = 20;
  68.  
  69. int quick_moves = 0;
  70. int auto_motion = 0;
  71.  
  72. XVisualInfo *find_visual() 
  73. {
  74.   int attr[256], i, stencil, dbuffer;
  75.   XVisualInfo *vi;
  76.  
  77.   i = 0;
  78.   attr[i++] = GLX_RGBA;
  79.   attr[i++] = GLX_RED_SIZE;
  80.   attr[i++] = 1;
  81.   attr[i++] = GLX_GREEN_SIZE;
  82.   attr[i++] = 1;
  83.   attr[i++] = GLX_BLUE_SIZE;
  84.   attr[i++] = 1;
  85.   attr[i++] = GLX_DEPTH_SIZE;
  86.   attr[i++] = 1;
  87.   dbuffer = i;
  88.   attr[i++] = GLX_DOUBLEBUFFER;
  89.   stencil = i;
  90.   attr[i++] = GLX_STENCIL_SIZE;
  91.   attr[i++] = 1;
  92.   attr[i++] = (int)None;
  93.  
  94.   vi = glXChooseVisual(display, DefaultScreen(display), attr);
  95.   if (vi == NULL) {
  96.     fprintf(stderr, "Unable to find visual with stencil buffer.\n");
  97.     fprintf(stderr, "(Things won't look quite as good).\n");
  98.     attr[stencil] = (int)None;
  99.     vi = glXChooseVisual(display, DefaultScreen(display), attr);
  100.     if (vi == NULL) {
  101.       fprintf(stderr, "Unable to find double-buffered visual.\n");
  102.       fprintf(stderr, "(Things will look even worse).\n");
  103.       attr[dbuffer] = (int)None;
  104.       vi = glXChooseVisual(display, DefaultScreen(display), attr);
  105.       if (vi == NULL) fprintf(stderr, "Can't find visual at all.\n");
  106.     }
  107.   }
  108.   return vi;
  109. }
  110.  
  111. Widget create_widgets(Widget parent)
  112. {
  113.   Widget main_window;
  114.   Widget menu_bar;
  115.   Widget menu_pane; 
  116.   Widget button;
  117.   Widget cascade;
  118.   Widget frame;
  119.   XVisualInfo *vi;
  120.  
  121.   Arg args[max_args];
  122.   int argcount;
  123.  
  124.   char buffer[128];
  125.  
  126.   int i;
  127.  
  128.   main_window = XmCreateMainWindow(parent, "main1", NULL, 0);
  129.   XtManageChild(main_window);
  130.  
  131.   menu_bar = XmCreateMenuBar(main_window, "menu_bar", NULL, 0);
  132.   XtManageChild(menu_bar);
  133.     
  134.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", NULL, 0);
  135.   button = XmCreatePushButton(menu_pane, "Exit", NULL, 0);
  136.   XtManageChild(button);
  137.   XtAddCallback(button, XmNactivateCallback, (XtCallbackProc)exitCB, NULL);
  138.       
  139.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  140.   cascade = XmCreateCascadeButton(menu_bar, "File", args, 1);
  141.   XtManageChild(cascade);
  142.  
  143.  
  144.   argcount = 0;
  145.   XtSetArg(args[argcount], XmNradioBehavior, True); argcount++;
  146.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", args, argcount);
  147.   XtSetArg(args[0], XmNset, TRUE);
  148.   for (i = 0; i < nindices; i++) {
  149.     if (i == def_refraction_index) argcount = 1;
  150.     else argcount = 0;
  151.     button = XmCreateToggleButton(menu_pane, (char *)indices[i].name, 
  152.     args, argcount);
  153.     XtManageChild(button);
  154.     XtAddCallback(button, XmNvalueChangedCallback, 
  155.           (XtCallbackProc)refractionCB, 
  156.           (XtPointer)(&indices[i].index));
  157.   }
  158.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  159.   cascade = XmCreateCascadeButton(menu_bar, "Material", args, 1);
  160.   XtManageChild(cascade);
  161.  
  162.  
  163.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", NULL, 0);
  164.  
  165.   XtSetArg(args[0], XmNset, draw_square);
  166.   button = XmCreateToggleButton(menu_pane, "Draw Square", args, 1);
  167.   XtManageChild(button);
  168.   XtAddCallback(button, XmNvalueChangedCallback, 
  169.                 (XtCallbackProc)drawSomethingCB, &draw_square);
  170.  
  171.   XtSetArg(args[0], XmNset, draw_shadows);
  172.   button = XmCreateToggleButton(menu_pane, "Draw Shadows", args, 1);
  173.   XtManageChild(button);
  174.   XtAddCallback(button, XmNvalueChangedCallback, 
  175.                 (XtCallbackProc)drawSomethingCB, &draw_shadows);
  176.  
  177.   XtSetArg(args[0], XmNset, draw_refraction);
  178.   button = XmCreateToggleButton(menu_pane, "Draw Refraction", args, 1);
  179.   XtManageChild(button);
  180.   XtAddCallback(button, XmNvalueChangedCallback, 
  181.                 (XtCallbackProc)drawSomethingCB, &draw_refraction);
  182.  
  183.   XtSetArg(args[0], XmNset, draw_sphere);
  184.   button = XmCreateToggleButton(menu_pane, "Draw Sphere", args, 1);
  185.   XtManageChild(button);
  186.   XtAddCallback(button, XmNvalueChangedCallback, 
  187.                 (XtCallbackProc)drawSomethingCB, &draw_sphere);
  188.  
  189.   XtSetArg(args[0], XmNset, draw_lights);
  190.   button = XmCreateToggleButton(menu_pane, "Draw Lights", args, 1);
  191.   XtManageChild(button);
  192.   XtAddCallback(button, XmNvalueChangedCallback, 
  193.                 (XtCallbackProc)drawSomethingCB, &draw_lights);
  194.  
  195. #ifdef TEXTURE
  196.   XtSetArg(args[0], XmNset, draw_texture);
  197.   button = XmCreateToggleButton(menu_pane, "Texture Map", args, 1);
  198.   XtManageChild(button);
  199.   XtAddCallback(button, XmNvalueChangedCallback, 
  200.                 (XtCallbackProc)drawSomethingCB, &draw_texture);
  201. #endif
  202.  
  203.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  204.   cascade = XmCreateCascadeButton(menu_bar, "Draw", args, 1);
  205.   XtManageChild(cascade);
  206.  
  207.   argcount = 0;
  208.   XtSetArg(args[argcount], XmNradioBehavior, True); argcount++;
  209.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", args, argcount);
  210.   XtSetArg(args[0], XmNset, TRUE);
  211.   for (i = 0; i < npossible_divisions; i++) {
  212.     if (i == def_divisions_index) argcount = 1;
  213.     else argcount = 0;
  214.     sprintf(buffer, "%d", possible_divisions[i]);
  215.     button = XmCreateToggleButton(menu_pane, buffer, args, argcount);
  216.     XtManageChild(button);
  217.     XtAddCallback(button, XmNvalueChangedCallback, 
  218.           (XtCallbackProc)subdivisionCB, &possible_divisions[i]);
  219.   }
  220.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  221.   cascade = XmCreateCascadeButton(menu_bar, "Subdivision", args, 1);
  222.   XtManageChild(cascade);
  223.  
  224.  
  225.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", args, argcount);
  226.   button = XmCreatePushButton(menu_pane, "Reset Position", NULL, 0);
  227.   XtManageChild(button);
  228.   XtAddCallback(button, XmNactivateCallback, 
  229.         (XtCallbackProc)resetLightsCB, NULL);
  230.  
  231.   XtSetArg(args[0], XmNset, TRUE);
  232.   for (i = 0; i < nlights; i++) {
  233.     button = XmCreateToggleButton(menu_pane, lights[i].name, args, 
  234.                   lights[i].on ? 1 : 0);
  235.     XtManageChild(button);
  236.     XtAddCallback(button, XmNvalueChangedCallback, 
  237.           (XtCallbackProc)light_onCB, &lights[i]);
  238.   }
  239.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  240.   cascade = XmCreateCascadeButton(menu_bar, "Lights", args, 1);
  241.   XtManageChild(cascade);
  242.  
  243.  
  244.   menu_pane = XmCreatePulldownMenu(menu_bar, "menu_pane", args,
  245.                    argcount);
  246.   XtSetArg(args[0], XmNset, quick_moves);
  247.   button = XmCreateToggleButton(menu_pane, "Quick Motion",
  248.                 args, 1);
  249.   XtManageChild(button);
  250.   XtAddCallback(button, XmNvalueChangedCallback, 
  251.         (XtCallbackProc)intToggleCB, &quick_moves);
  252.  
  253.   XtSetArg(args[0], XmNset, auto_motion);
  254.   button = XmCreateToggleButton(menu_pane, "Rotate Automatically",
  255.                 args, 1);
  256.   XtManageChild(button);
  257.   XtAddCallback(button, XmNvalueChangedCallback, 
  258.         (XtCallbackProc)autoMotionCB, NULL);
  259.  
  260.   XtSetArg(args[0], XmNsubMenuId, menu_pane);
  261.   cascade = XmCreateCascadeButton(menu_bar, "Motion", args, 1);
  262.   XtManageChild(cascade);
  263.  
  264.  
  265.   argcount = 0;
  266.   XtSetArg(args[argcount], XmNmarginWidth, 0); argcount++;
  267.   XtSetArg(args[argcount], XmNmarginHeight, 0); argcount++;
  268.   XtSetArg(args[argcount], XmNshadowThickness, 1); argcount++;
  269.   XtSetArg(args[argcount], XmNshadowType, XmSHADOW_OUT); argcount++;
  270.   frame = XmCreateFrame(main_window, "frame", args, argcount);
  271.   XtManageChild(frame);
  272.  
  273.  
  274.   argcount = 0;
  275.   vi = find_visual();
  276.   if (vi) {
  277.     XtSetArg(args[argcount], GLwNvisualInfo, vi); argcount++;
  278.   }
  279.   else {
  280.     XtSetArg(args[argcount], GLwNrgba, TRUE); argcount++;
  281.     XtSetArg(args[argcount], GLwNdepthSize, 1); argcount++;
  282.     XtSetArg(args[argcount], GLwNdoublebuffer, TRUE); argcount++;
  283.   }
  284.   XtSetArg(args[argcount], XmNbottomAttachment, XmATTACH_FORM); argcount++;
  285.   XtSetArg(args[argcount], XmNtopAttachment, XmATTACH_FORM); argcount++;
  286.   XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_FORM); argcount++;
  287.   XtSetArg(args[argcount], XmNrightAttachment, XmATTACH_FORM); argcount++;
  288.   glw = GLwCreateMDrawingArea(frame, "glwidget", args, argcount);
  289.   XtManageChild(glw);
  290.   XtAddCallback(glw, GLwNginitCallback, (XtCallbackProc)initCB, 0);
  291.   XtAddCallback(glw, GLwNexposeCallback, (XtCallbackProc)exposeCB, 0);
  292.   XtAddCallback(glw, GLwNresizeCallback, (XtCallbackProc)resizeCB, 0);
  293.   XtAddCallback(glw, GLwNinputCallback, (XtCallbackProc)inputCB, 0);
  294.  
  295.   return main_window;
  296. }
  297.  
  298. void main(int argc, char **argv)
  299. {
  300.   Widget app_shell;
  301.   Arg args[max_args];
  302.   int argcount;
  303.  
  304.   scene_load_texture((char *)def_texfile);
  305.  
  306.   XtToolkitInitialize();
  307.   app_context = XtCreateApplicationContext();
  308.   display = XtOpenDisplay(app_context, NULL, argv[0],
  309.                           "XMdemos", NULL, 0, &argc, argv);
  310.   if (!display) {
  311.     XtWarning("Can't open display.");
  312.     exit(0);
  313.   }
  314.  
  315.   argcount = 0;
  316.   XtSetArg(args[argcount], XmNmaxAspectX, 1); argcount++;
  317.   XtSetArg(args[argcount], XmNmaxAspectY, 1); argcount++;
  318.   XtSetArg(args[argcount], XmNminAspectX, 1); argcount++;
  319.   XtSetArg(args[argcount], XmNminAspectY, 1); argcount++;
  320.   app_shell = 
  321.     XtAppCreateShell(argv[0], "XMdemos", applicationShellWidgetClass,
  322.                      display, args, argcount);
  323.   
  324.   create_widgets(app_shell);
  325.  
  326.   XtRealizeWidget(app_shell);
  327.  
  328.   XtAppMainLoop(app_context);
  329.   
  330. }
  331.